home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / datelib.exe / WREADDAT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-27  |  9.6 KB  |  292 lines
  1. static char wreaddate_prg1[] =
  2. "@(#)char *wreaddatew(WINDOW *win,int f, char *dstr) - Datum einlesen (Curses-win)";
  3. static char wreaddate_prg2[] =
  4. "@(#)char *readdatew(int f, char *dstr) - Datum einlesen (Curses-stdscr)";
  5. static char wreaddate_ver[] = "@(#)v1.00/kr ; 01.08.91";
  6. /* [w]readdatew     Einlesen eines Datum-String - Curses-Version
  7. **
  8. ** Autor            Klaus Rath
  9. **
  10. ** Deklaration      char *wreaddatew(WINDOW *win,int format, char *datestring);
  11. **
  12. ** Compilation      DOS:  bcc -c wreaddate.c c:\usr\local\lib\libkrc_s.lib
  13. **                  UNIX: cc  -c wreaddate.c /u1/usr/lib/libkrc.a
  14. **                  ( unter DOS kann die Funktion im small-Modell laufen )
  15. **
  16. ** Übergabe         Die Funktion erwartet einen Integer, der angibt in wel-
  17. **                  chem Format eingelesen werden soll.
  18. **                  Z.Zt. erlaubte Formate (siehe datum.h) :
  19. **                  tt.mm.[jj]jj     -- Deutsches Format       (format: 1,2)
  20. **                  mm/tt/[jj]jj     -- Amerikanisches Format  (format: 3,4)
  21. **                  [jj]jjmmtt       -- Datenbankformat DDB/4  (format: 5,6)
  22. **                  tt.mm. | mm/tt   -- Kurzformat deutsch/am. (format: 7,8).
  23. **                  Außerdem wird ein Zeiger auf ein char-Array zur Aufnahme
  24. **                  des Ergebnisses erwartet.
  25. **
  26. ** Rückgabe         (char *) auf datestring
  27. **
  28. ** Anmerkungen      Die Funktion prüft nicht die Validität des eingegebenen
  29. **                  Datums - dies sollte die aufrufende Funktion selbst tun,
  30. **                  bzw. den Test durch checkdate() durchführen lassen.
  31. **                  Die Funktion benutzt zum Einlesen wgetch(win).
  32. **                  wreaddate() stellt dem Aufrufer eine Maske des angeforder-
  33. **                  ten Format zur Verfügung ( z.B. __.__.__ ), wobei die
  34. **                  Unterstriche durch Zahlen gefüllt werden müssen. Die
  35. **                  u.U. nötigen Trennzeichen sind im Gegensatz zu den Zahlen
  36. **                  nicht editierbar und werden automatisch erzeugt. Eine
  37. **                  Korrektur der Zahlen ist über die BACKSPACE-Taste möglich.
  38. **                  Die Eingabe von RETURN oder ESCAPE beendet die Eingabe
  39. **                  immer, hinter der letzten Position genügt ein beliebige
  40. **                  Tastendruck dafür - außer BACKSPACE, wg. Korrektur.
  41. **
  42. ** Änderungen       1.00 ; 01.08.91
  43. **                  - Erste Version für CURSES, basiert auf Version 1.10 von
  44. **                    readdate().
  45. **                  1.01 ; 12.12.91
  46. **                  - Einlesefehler beseitigt: obwohl für ein WINDOW *win
  47. **                    konzipiert, wurde in wreaddate() mit getch() gelesen.
  48. */
  49.  
  50. #include <curses.h>
  51. #include <string.h>
  52. #ifdef __TURBOC__
  53. #define ANSI
  54. #define KR_SYS
  55. #include <stdlib.h>
  56. #include "datum.h"
  57. #include "util.h"
  58. #else
  59. #include "/u1/usr/include/datum.h"
  60. #include "/u1/usr/include/util.h"
  61. #endif
  62.  
  63. /* Normalversion :
  64. */
  65. #ifdef ANSI
  66. char *wreaddatew(WINDOW *win,int format, char *dstring)
  67. #else
  68. char *wreaddatew(win,format,dstring)
  69. WINDOW *win;
  70. int     format;
  71. char   *dstring;
  72. #endif
  73. {
  74.     /* Variablendefinitionen :
  75.     */
  76.     int trennpos1 = 2,                       /* Positionen von Trennzeichen */
  77.         trennpos2 = 5;
  78.     int trenner;                             /* das Trennzeichen            */
  79.     int pos       = 0;                       /* Aktuelle Position           */
  80.     int maxpos    = 11;                      /* Letztmögliche Position      */
  81.     int Max       = 0;                       /* Schalter, ob am Ende        */
  82.     int ch;                                  /* Einzulesendes Zeichen       */
  83.     int def_char  = '_';                     /* Default-Character           */
  84.  
  85.     /* Evtl. 1. Zeichen berücksichtigen :
  86.     */
  87.     if ( dstring[0] == NULL ) {
  88.         dstring[0] = def_char;
  89.     }
  90.     else {
  91.         pos = 1;
  92.     }
  93.  
  94.     /* Format überprüfen, String vorbelegen, Anzeigemaske erzeugen :
  95.     */
  96.     switch ( format ) {
  97.         case DE_KURZ :
  98.             trenner            = '.';
  99.             maxpos             = 9;
  100.             dstring[trennpos1] =
  101.             dstring[trennpos2] = trenner;
  102.             wprintw(win,"%c_.__.__",dstring[0]);
  103.             wprintw(win,"\b\b\b\b\b\b\b");
  104.             break;
  105.         case DE_LANG :
  106.             trenner            = '.';
  107.             maxpos             = 11;
  108.             dstring[trennpos1] =
  109.             dstring[trennpos2] = trenner;
  110.             wprintw(win,"%c_.__.____",dstring[0]);
  111.             wprintw(win,"\b\b\b\b\b\b\b\b\b");
  112.             break;
  113.         case AM_KURZ :
  114.             trenner            = '/';
  115.             maxpos             = 9;
  116.             dstring[trennpos1] =
  117.             dstring[trennpos2] = trenner;
  118.             wprintw(win,"%c_/__/__",dstring[0]);
  119.             wprintw(win,"\b\b\b\b\b\b\b");
  120.             break;
  121.         case AM_LANG :
  122.             trenner            = '/';
  123.             maxpos             = 11;
  124.             dstring[trennpos1] =
  125.             dstring[trennpos2] = trenner;
  126.             wprintw(win,"%c_/__/____",dstring[0]);
  127.             wprintw(win,"\b\b\b\b\b\b\b\b\b\b");
  128.             break;
  129.         case DB_KURZ :
  130.             maxpos    = 7;
  131.             trennpos1 =
  132.             trennpos2 = 99;
  133.             wprintw(win,"%c_____",dstring[0]);
  134.             wprintw(win,"\b\b\b\b\b");
  135.             break;
  136.         case DB_LANG :
  137.             maxpos    = 9;
  138.             trennpos1 =
  139.             trennpos2 = 99;
  140.             wprintw(win,"%c_______",dstring[0]);
  141.             wprintw(win,"\b\b\b\b\b\b\b");
  142.             break;
  143.         case DE_AKTJAHR :
  144.             trenner            = '.';
  145.             maxpos             = 7;
  146.             dstring[trennpos1] =
  147.             dstring[trennpos2] = trenner;
  148.             wprintw(win,"%c_.__.",dstring[0]);
  149.             wprintw(win,"\b\b\b\b\b");
  150.             break;
  151.         case AM_AKTJAHR :
  152.             trenner            = '/';
  153.             maxpos             = 6;
  154.             dstring[trennpos1] = trenner;
  155.             trennpos2 = 99;
  156.             wprintw(win,"%c_/__",dstring[0]);
  157.             wprintw(win,"\b\b\b\b");
  158.             break;
  159.         default:
  160.             trenner            = '.';
  161.             maxpos             = 9;
  162.             dstring[trennpos1] =
  163.             dstring[trennpos2] = trenner;
  164.     } /* ENDE: switch(format) */
  165.  
  166.     /* Evtl. noch ein Rückschritt :
  167.     */
  168.     if ( !pos ) {
  169.         wprintw(win,"\b");
  170.     }
  171.     wrefresh(win);
  172.  
  173.     /* Tastendrucke abholen, bis maxpos :
  174.     */
  175.     while ( pos < maxpos + 1 ) {
  176.  
  177.         if ( pos == 0 ) {
  178.             dstring[pos] = def_char;
  179.         }
  180.         wrefresh(win);
  181.  
  182.         /* Falls fertig, String zurückgeben :
  183.         */
  184.         if ( pos == maxpos ) {
  185.             dstring[pos] = '\0';
  186.             return(dstring);
  187.         }
  188.         /* An eventuellen Trennerpositionen den passenden Trenner einfügen
  189.         ** und den nächsten Schleifendurchlauf abwarten :
  190.         */
  191.         if ( pos == trennpos1 || pos == trennpos2 ) {
  192.             wprintw(win,"%c",trenner);
  193.             wrefresh(win);
  194.             pos++;
  195.             continue;
  196.         }
  197.         /* An der vorletzten Position sind alle Tasten erlaubt, denn nur
  198.         ** BACKSPACE bleibt in der Funktion :
  199.         */
  200.         if ( pos == maxpos - 1 ) {
  201.             Max = 1;
  202.         }
  203.         ch  = wgetch(win);
  204.  
  205.         /* Auswertung der gedrückten Taste :
  206.         */
  207.         switch ( ch ) {
  208.  
  209.             /* Nicht Zulässiges ignorieren :
  210.             */
  211.             case NULL:
  212.             case -1  :
  213.                        break;
  214.  
  215.             /* Abbruchmöglichkeiten :
  216.             */
  217.             case 27  :
  218.                 dstring[0] = '\0';
  219.                 return(dstring);
  220.             case 10  :
  221.             case 13  :
  222.                 dstring[pos] = '\0';
  223.                 return(dstring);
  224.  
  225.             /* Korrekturmöglichkeit :
  226.             */
  227.             case  8  :
  228.                 dstring[pos] = def_char;
  229.                 if ( pos == 0 ) {
  230.                     break;
  231.                 }
  232.  
  233.                 /* Schalter für MAX-Position zurücksetzen :
  234.                 */
  235.                 if ( Max )
  236.                     Max = 0;
  237.  
  238.                 /* Trenner überspringen und Maskendefault anzeigen :
  239.                 */
  240.                 if ( pos == trennpos1 + 1 || pos == trennpos2 + 1 ) {
  241.                     wprintw(win,"\b\b%c\b",def_char);
  242.                     wrefresh(win);
  243.                     pos -= 2;
  244.                     break;
  245.                 }
  246.  
  247.                 /* Ansonsten zurück und Maskendefault anzeigen :
  248.                 */
  249.                 if ( pos ) {
  250.                     pos--;
  251.                 }
  252.                 wprintw(win,"\b%c\b",def_char);
  253.                 wrefresh(win);
  254.                 break;
  255.             default  :
  256.                 /* Falls wir fertig sind, String abschließen und
  257.                 ** zurückgeben :
  258.                 */
  259.                 if ( Max ) {
  260.                     dstring[pos] = '\0';
  261.                     return(dstring);
  262.                 }
  263.  
  264.                 /* Ansonsten ist es eine Zahl, die angezeigt und ein-
  265.                 ** getragen wird :
  266.                 */
  267.                 if ( ch > '9' || ch < '0' ) {
  268.                     break;
  269.                 }
  270.                 wprintw(win,"%c",ch);
  271.                 wrefresh(win);
  272.                 dstring[pos] = ch;
  273.                 pos++;
  274.  
  275.         } /* ENDE: switch(ch) */
  276.     } /* ENDE: while(pos) */
  277.  
  278.     return(dstring);
  279.  
  280. } /* ENDE: wreaddatew() */
  281.  
  282. /* Version für stdscr :
  283. */
  284. char *readdatew(format,dstring)
  285. int  format;
  286. char *dstring;
  287. {
  288.   wreaddatew(stdscr,format,dstring);
  289.   return(dstring);
  290. } /* ENDE: readdatew() */
  291.  
  292.